home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Interfaces & Libraries / Interfaces / PInterfaces / Quickdraw.p < prev    next >
Encoding:
Text File  |  1995-08-24  |  50.5 KB  |  1,816 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Quickdraw.p
  3.  
  4.      Contains:    QuickDraw Graphics Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.1.1 in “MPW Latest” on ETO #19
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT Quickdraw;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __QUICKDRAW__}
  30. {$SETC __QUICKDRAW__ := 1}
  31.  
  32. {$I+}
  33. {$SETC QuickdrawIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __MIXEDMODE__}
  43. {$I MixedMode.p}
  44. {$ENDC}
  45.  
  46. {$IFC UNDEFINED __QUICKDRAWTEXT__}
  47. {$I QuickdrawText.p}
  48. {$ENDC}
  49.  
  50. {$PUSH}
  51. {$ALIGN MAC68K}
  52. {$LibExport+}
  53.  
  54. CONST
  55.     invalColReq                    = -1;                            {invalid color table request}
  56. { transfer modes }
  57.     srcCopy                        = 0;                            {the 16 transfer modes}
  58.     srcOr                        = 1;
  59.     srcXor                        = 2;
  60.     srcBic                        = 3;
  61.     notSrcCopy                    = 4;
  62.     notSrcOr                    = 5;
  63.     notSrcXor                    = 6;
  64.     notSrcBic                    = 7;
  65.     patCopy                        = 8;
  66.     patOr                        = 9;
  67.     patXor                        = 10;
  68.     patBic                        = 11;
  69.     notPatCopy                    = 12;
  70.     notPatOr                    = 13;
  71.     notPatXor                    = 14;
  72.     notPatBic                    = 15;
  73. { Special Text Transfer Mode }
  74.     grayishTextOr                = 49;
  75.     hilitetransfermode            = 50;
  76. { Arithmetic transfer modes }
  77.     blend                        = 32;
  78.     addPin                        = 33;
  79.  
  80.     addOver                        = 34;
  81.     subPin                        = 35;
  82.     addMax                        = 37;
  83.     adMax                        = 37;
  84.     subOver                        = 38;
  85.     adMin                        = 39;
  86.     ditherCopy                    = 64;
  87. { Transparent mode constant }
  88.     transparent                    = 36;
  89.     italicBit                    = 1;
  90.     ulineBit                    = 2;
  91.     outlineBit                    = 3;
  92.     shadowBit                    = 4;
  93.     condenseBit                    = 5;
  94.     extendBit                    = 6;
  95. { QuickDraw color separation constants }
  96.     normalBit                    = 0;                            {normal screen mapping}
  97.     inverseBit                    = 1;                            {inverse screen mapping}
  98.     redBit                        = 4;                            {RGB additive mapping}
  99.     greenBit                    = 3;
  100.     blueBit                        = 2;
  101.     cyanBit                        = 8;                            {CMYBk subtractive mapping}
  102.     magentaBit                    = 7;
  103.     yellowBit                    = 6;
  104.     blackBit                    = 5;
  105.     blackColor                    = 33;                            {colors expressed in these mappings}
  106.     whiteColor                    = 30;
  107.     redColor                    = 205;
  108.  
  109.     greenColor                    = 341;
  110.     blueColor                    = 409;
  111.     cyanColor                    = 273;
  112.     magentaColor                = 137;
  113.     yellowColor                    = 69;
  114.     picLParen                    = 0;                            {standard picture comments}
  115.     picRParen                    = 1;
  116.     clutType                    = 0;                            {0 if lookup table}
  117.     fixedType                    = 1;                            {1 if fixed table}
  118.     directType                    = 2;                            {2 if direct values}
  119.     gdDevType                    = 0;                            {0 = monochrome 1 = color}
  120.  
  121.     interlacedDevice            = 2;                            { 1 if single pixel lines look bad }
  122.     roundedDevice                = 5;                            { 1 if device has been “rounded” into the GrayRgn }
  123.     hasAuxMenuBar                = 6;                            { 1 if device has an aux menu bar on it }
  124.     burstDevice                    = 7;
  125.     ext32Device                    = 8;
  126.     ramInit                        = 10;                            {1 if initialized from 'scrn' resource}
  127.     mainScreen                    = 11;                            { 1 if main screen }
  128.     allInit                        = 12;                            { 1 if all devices initialized }
  129.     screenDevice                = 13;                            {1 if screen device [not used]}
  130.     noDriver                    = 14;                            { 1 if no driver for this GDevice }
  131.     screenActive                = 15;                            {1 if in use}
  132.     hiliteBit                    = 7;                            {flag bit in HiliteMode (lowMem flag)}
  133.     pHiliteBit                    = 0;                            {flag bit in HiliteMode used with BitClr procedure}
  134.     defQDColors                    = 127;                            {resource ID of clut for default QDColors}
  135. { pixel type }
  136.     RGBDirect                    = 16;                            { 16 & 32 bits/pixel pixelType value }
  137. { pmVersion values }
  138.     baseAddr32                    = 4;                            {pixmap base address is 32-bit address}
  139.  
  140.     sysPatListID                = 0;
  141.     iBeamCursor                    = 1;
  142.     crossCursor                    = 2;
  143.     plusCursor                    = 3;
  144.     watchCursor                    = 4;
  145.  
  146.     kQDGrafVerbFrame            = 0;
  147.     kQDGrafVerbPaint            = 1;
  148.     kQDGrafVerbErase            = 2;
  149.     kQDGrafVerbInvert            = 3;
  150.     kQDGrafVerbFill                = 4;
  151.  
  152. {$IFC OLDROUTINENAMES }
  153.     frame                        = kQDGrafVerbFrame;
  154.     paint                        = kQDGrafVerbPaint;
  155.     erase                        = kQDGrafVerbErase;
  156.     invert                        = kQDGrafVerbInvert;
  157.     fill                        = kQDGrafVerbFill;
  158. {$ENDC}
  159.  
  160. TYPE
  161.     GrafVerb = SInt8;
  162.  
  163.  
  164. CONST
  165.     chunky                        = 0;
  166.     chunkyPlanar                = 1;
  167.     planar                        = 2;
  168.  
  169.     
  170. TYPE
  171.     PixelType = SInt8;
  172.  
  173.     Bits16 = ARRAY [0..15] OF INTEGER;
  174.  
  175. {**************   IMPORTANT NOTE REGARDING Pattern  **************************************
  176.    Patterns were originally defined as:
  177.    
  178.         C:             typedef unsigned char Pattern[8];
  179.         Pascal:        Pattern = PACKED ARRAY [0..7] OF 0..255;
  180.         
  181.    The old array defintion of Pattern would cause 68000 based CPU's to crash in certain circum-
  182.    stances. The new struct definition is safe, but may require source code changes to compile.
  183.    Read the details in TechNote "Platforms & Tools" #PT 38.
  184.     
  185. ********************************************************************************************}
  186.     Pattern = RECORD
  187.         pat:                    PACKED ARRAY [0..7] OF SInt8; (* UInt8 *)
  188.     END;
  189.  
  190. {
  191.  ConstPatternParam is now longer needed.  It was first created when Pattern was an array.
  192.  Now that Pattern is a struct, it is more straight forward just add the "const" qualifier
  193.  on the parameter type (e.g. "const Pattern * pat" instead of "ConstPatternParam pat").
  194. }
  195.     PatPtr = ^Pattern;
  196.  
  197.     PatHandle = ^PatPtr;
  198.  
  199.     QDByte = SignedByte;
  200.  
  201.     QDPtr = Ptr;
  202.  
  203.     QDHandle = Handle;
  204.  
  205.     QDErr = INTEGER;
  206.  
  207.  
  208. CONST
  209.     singleDevicesBit            = 0;
  210.     dontMatchSeedsBit            = 1;
  211.     allDevicesBit                = 2;
  212.  
  213.     singleDevices                = 1 * (2**(singleDevicesBit));
  214.     dontMatchSeeds                = 1 * (2**(dontMatchSeedsBit));
  215.     allDevices                    = 1 * (2**(allDevicesBit));
  216.  
  217.     
  218. TYPE
  219.     DeviceLoopFlags = LONGINT;
  220.  
  221.     BitMap = RECORD
  222.         baseAddr:                Ptr;
  223.         rowBytes:                INTEGER;
  224.         bounds:                    Rect;
  225.     END;
  226.  
  227.     BitMapPtr = ^BitMap;
  228.     BitMapHandle = ^BitMapPtr;
  229.  
  230.     Cursor = RECORD
  231.         data:                    Bits16;
  232.         mask:                    Bits16;
  233.         hotSpot:                Point;
  234.     END;
  235.  
  236.     CursPtr = ^Cursor;
  237.     CursHandle = ^CursPtr;
  238.  
  239.     PenState = RECORD
  240.         pnLoc:                    Point;
  241.         pnSize:                    Point;
  242.         pnMode:                    INTEGER;
  243.         pnPat:                    Pattern;
  244.     END;
  245.  
  246.     Region = RECORD
  247.         rgnSize:                INTEGER;                                {size in bytes}
  248.         rgnBBox:                Rect;                                    {enclosing rectangle}
  249.     END;
  250.  
  251.     RgnPtr = ^Region;
  252.     RgnHandle = ^RgnPtr;
  253.  
  254.     Picture = RECORD
  255.         picSize:                INTEGER;
  256.         picFrame:                Rect;
  257.     END;
  258.  
  259.     PicPtr = ^Picture;
  260.     PicHandle = ^PicPtr;
  261.  
  262.     Polygon = RECORD
  263.         polySize:                INTEGER;
  264.         polyBBox:                Rect;
  265.         polyPoints:                ARRAY [0..0] OF Point;
  266.     END;
  267.  
  268.     PolyPtr = ^Polygon;
  269.     PolyHandle = ^PolyPtr;
  270.  
  271.     QDTextProcPtr = ProcPtr;  { PROCEDURE QDText(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point); }
  272.     QDLineProcPtr = ProcPtr;  { PROCEDURE QDLine(newPt: Point); }
  273.     QDRectProcPtr = ProcPtr;  { PROCEDURE QDRect(verb: ByteParameter; VAR r: Rect); }
  274.     QDRRectProcPtr = ProcPtr;  { PROCEDURE QDRRect(verb: ByteParameter; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER); }
  275.     QDOvalProcPtr = ProcPtr;  { PROCEDURE QDOval(verb: ByteParameter; VAR r: Rect); }
  276.     QDArcProcPtr = ProcPtr;  { PROCEDURE QDArc(verb: ByteParameter; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER); }
  277.     QDPolyProcPtr = ProcPtr;  { PROCEDURE QDPoly(verb: ByteParameter; poly: PolyHandle); }
  278.     QDRgnProcPtr = ProcPtr;  { PROCEDURE QDRgn(verb: ByteParameter; rgn: RgnHandle); }
  279.     QDBitsProcPtr = ProcPtr;  { PROCEDURE QDBits(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle); }
  280.     QDCommentProcPtr = ProcPtr;  { PROCEDURE QDComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle); }
  281.     QDTxMeasProcPtr = ProcPtr;  { FUNCTION QDTxMeas(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo): INTEGER; }
  282.     QDGetPicProcPtr = ProcPtr;  { PROCEDURE QDGetPic(dataPtr: Ptr; byteCount: INTEGER); }
  283.     QDPutPicProcPtr = ProcPtr;  { PROCEDURE QDPutPic(dataPtr: Ptr; byteCount: INTEGER); }
  284.     QDOpcodeProcPtr = ProcPtr;  { PROCEDURE QDOpcode(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER); }
  285.     QDJShieldCursorProcPtr = ProcPtr;  { PROCEDURE QDJShieldCursor(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER); }
  286.     QDTextUPP = UniversalProcPtr;
  287.     QDLineUPP = UniversalProcPtr;
  288.     QDRectUPP = UniversalProcPtr;
  289.     QDRRectUPP = UniversalProcPtr;
  290.     QDOvalUPP = UniversalProcPtr;
  291.     QDArcUPP = UniversalProcPtr;
  292.     QDPolyUPP = UniversalProcPtr;
  293.     QDRgnUPP = UniversalProcPtr;
  294.     QDBitsUPP = UniversalProcPtr;
  295.     QDCommentUPP = UniversalProcPtr;
  296.     QDTxMeasUPP = UniversalProcPtr;
  297.     QDGetPicUPP = UniversalProcPtr;
  298.     QDPutPicUPP = UniversalProcPtr;
  299.     QDOpcodeUPP = UniversalProcPtr;
  300.     QDJShieldCursorUPP = UniversalProcPtr;
  301.  
  302.     QDProcs = RECORD
  303.         textProc:                QDTextUPP;
  304.         lineProc:                QDLineUPP;
  305.         rectProc:                QDRectUPP;
  306.         rRectProc:                QDRRectUPP;
  307.         ovalProc:                QDOvalUPP;
  308.         arcProc:                QDArcUPP;
  309.         polyProc:                QDPolyUPP;
  310.         rgnProc:                QDRgnUPP;
  311.         bitsProc:                QDBitsUPP;
  312.         commentProc:            QDCommentUPP;
  313.         txMeasProc:                QDTxMeasUPP;
  314.         getPicProc:                QDGetPicUPP;
  315.         putPicProc:                QDPutPicUPP;
  316.     END;
  317.  
  318.     QDProcsPtr = ^QDProcs;
  319.  
  320. CONST
  321.     uppQDTextProcInfo = $00003F80; { PROCEDURE (2 byte param, 4 byte param, 4 byte param, 4 byte param); }
  322.     uppQDLineProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  323.     uppQDRectProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  324.     uppQDRRectProcInfo = $00002B40; { PROCEDURE (1 byte param, 4 byte param, 2 byte param, 2 byte param); }
  325.     uppQDOvalProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  326.     uppQDArcProcInfo = $00002B40; { PROCEDURE (1 byte param, 4 byte param, 2 byte param, 2 byte param); }
  327.     uppQDPolyProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  328.     uppQDRgnProcInfo = $00000340; { PROCEDURE (1 byte param, 4 byte param); }
  329.     uppQDBitsProcInfo = $0000EFC0; { PROCEDURE (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param); }
  330.     uppQDCommentProcInfo = $00000E80; { PROCEDURE (2 byte param, 2 byte param, 4 byte param); }
  331.     uppQDTxMeasProcInfo = $0000FFA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  332.     uppQDGetPicProcInfo = $000002C0; { PROCEDURE (4 byte param, 2 byte param); }
  333.     uppQDPutPicProcInfo = $000002C0; { PROCEDURE (4 byte param, 2 byte param); }
  334.     uppQDOpcodeProcInfo = $00002BC0; { PROCEDURE (4 byte param, 4 byte param, 2 byte param, 2 byte param); }
  335.     uppQDJShieldCursorProcInfo = $00002A80; { PROCEDURE (2 byte param, 2 byte param, 2 byte param, 2 byte param); }
  336.  
  337. FUNCTION NewQDTextProc(userRoutine: QDTextProcPtr): QDTextUPP;
  338.     {$IFC NOT GENERATINGCFM }
  339.     INLINE $2E9F;
  340.     {$ENDC}
  341.  
  342. FUNCTION NewQDLineProc(userRoutine: QDLineProcPtr): QDLineUPP;
  343.     {$IFC NOT GENERATINGCFM }
  344.     INLINE $2E9F;
  345.     {$ENDC}
  346.  
  347. FUNCTION NewQDRectProc(userRoutine: QDRectProcPtr): QDRectUPP;
  348.     {$IFC NOT GENERATINGCFM }
  349.     INLINE $2E9F;
  350.     {$ENDC}
  351.  
  352. FUNCTION NewQDRRectProc(userRoutine: QDRRectProcPtr): QDRRectUPP;
  353.     {$IFC NOT GENERATINGCFM }
  354.     INLINE $2E9F;
  355.     {$ENDC}
  356.  
  357. FUNCTION NewQDOvalProc(userRoutine: QDOvalProcPtr): QDOvalUPP;
  358.     {$IFC NOT GENERATINGCFM }
  359.     INLINE $2E9F;
  360.     {$ENDC}
  361.  
  362. FUNCTION NewQDArcProc(userRoutine: QDArcProcPtr): QDArcUPP;
  363.     {$IFC NOT GENERATINGCFM }
  364.     INLINE $2E9F;
  365.     {$ENDC}
  366.  
  367. FUNCTION NewQDPolyProc(userRoutine: QDPolyProcPtr): QDPolyUPP;
  368.     {$IFC NOT GENERATINGCFM }
  369.     INLINE $2E9F;
  370.     {$ENDC}
  371.  
  372. FUNCTION NewQDRgnProc(userRoutine: QDRgnProcPtr): QDRgnUPP;
  373.     {$IFC NOT GENERATINGCFM }
  374.     INLINE $2E9F;
  375.     {$ENDC}
  376.  
  377. FUNCTION NewQDBitsProc(userRoutine: QDBitsProcPtr): QDBitsUPP;
  378.     {$IFC NOT GENERATINGCFM }
  379.     INLINE $2E9F;
  380.     {$ENDC}
  381.  
  382. FUNCTION NewQDCommentProc(userRoutine: QDCommentProcPtr): QDCommentUPP;
  383.     {$IFC NOT GENERATINGCFM }
  384.     INLINE $2E9F;
  385.     {$ENDC}
  386.  
  387. FUNCTION NewQDTxMeasProc(userRoutine: QDTxMeasProcPtr): QDTxMeasUPP;
  388.     {$IFC NOT GENERATINGCFM }
  389.     INLINE $2E9F;
  390.     {$ENDC}
  391.  
  392. FUNCTION NewQDGetPicProc(userRoutine: QDGetPicProcPtr): QDGetPicUPP;
  393.     {$IFC NOT GENERATINGCFM }
  394.     INLINE $2E9F;
  395.     {$ENDC}
  396.  
  397. FUNCTION NewQDPutPicProc(userRoutine: QDPutPicProcPtr): QDPutPicUPP;
  398.     {$IFC NOT GENERATINGCFM }
  399.     INLINE $2E9F;
  400.     {$ENDC}
  401.  
  402. FUNCTION NewQDOpcodeProc(userRoutine: QDOpcodeProcPtr): QDOpcodeUPP;
  403.     {$IFC NOT GENERATINGCFM }
  404.     INLINE $2E9F;
  405.     {$ENDC}
  406.  
  407. FUNCTION NewQDJShieldCursorProc(userRoutine: QDJShieldCursorProcPtr): QDJShieldCursorUPP;
  408.     {$IFC NOT GENERATINGCFM }
  409.     INLINE $2E9F;
  410.     {$ENDC}
  411.  
  412. PROCEDURE CallQDTextProc(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point; userRoutine: QDTextUPP);
  413.     {$IFC NOT GENERATINGCFM}
  414.     INLINE $205F, $4E90;
  415.     {$ENDC}
  416.  
  417. PROCEDURE CallQDLineProc(newPt: Point; userRoutine: QDLineUPP);
  418.     {$IFC NOT GENERATINGCFM}
  419.     INLINE $205F, $4E90;
  420.     {$ENDC}
  421.  
  422. PROCEDURE CallQDRectProc(verb: ByteParameter; VAR r: Rect; userRoutine: QDRectUPP);
  423.     {$IFC NOT GENERATINGCFM}
  424.     INLINE $205F, $4E90;
  425.     {$ENDC}
  426.  
  427. PROCEDURE CallQDRRectProc(verb: ByteParameter; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; userRoutine: QDRRectUPP);
  428.     {$IFC NOT GENERATINGCFM}
  429.     INLINE $205F, $4E90;
  430.     {$ENDC}
  431.  
  432. PROCEDURE CallQDOvalProc(verb: ByteParameter; VAR r: Rect; userRoutine: QDOvalUPP);
  433.     {$IFC NOT GENERATINGCFM}
  434.     INLINE $205F, $4E90;
  435.     {$ENDC}
  436.  
  437. PROCEDURE CallQDArcProc(verb: ByteParameter; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; userRoutine: QDArcUPP);
  438.     {$IFC NOT GENERATINGCFM}
  439.     INLINE $205F, $4E90;
  440.     {$ENDC}
  441.  
  442. PROCEDURE CallQDPolyProc(verb: ByteParameter; poly: PolyHandle; userRoutine: QDPolyUPP);
  443.     {$IFC NOT GENERATINGCFM}
  444.     INLINE $205F, $4E90;
  445.     {$ENDC}
  446.  
  447. PROCEDURE CallQDRgnProc(verb: ByteParameter; rgn: RgnHandle; userRoutine: QDRgnUPP);
  448.     {$IFC NOT GENERATINGCFM}
  449.     INLINE $205F, $4E90;
  450.     {$ENDC}
  451.  
  452. PROCEDURE CallQDBitsProc(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle; userRoutine: QDBitsUPP);
  453.     {$IFC NOT GENERATINGCFM}
  454.     INLINE $205F, $4E90;
  455.     {$ENDC}
  456.  
  457. PROCEDURE CallQDCommentProc(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle; userRoutine: QDCommentUPP);
  458.     {$IFC NOT GENERATINGCFM}
  459.     INLINE $205F, $4E90;
  460.     {$ENDC}
  461.  
  462. FUNCTION CallQDTxMeasProc(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo; userRoutine: QDTxMeasUPP): INTEGER;
  463.     {$IFC NOT GENERATINGCFM}
  464.     INLINE $205F, $4E90;
  465.     {$ENDC}
  466.  
  467. PROCEDURE CallQDGetPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDGetPicUPP);
  468.     {$IFC NOT GENERATINGCFM}
  469.     INLINE $205F, $4E90;
  470.     {$ENDC}
  471.  
  472. PROCEDURE CallQDPutPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDPutPicUPP);
  473.     {$IFC NOT GENERATINGCFM}
  474.     INLINE $205F, $4E90;
  475.     {$ENDC}
  476.  
  477. PROCEDURE CallQDOpcodeProc(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER; userRoutine: QDOpcodeUPP);
  478.     {$IFC NOT GENERATINGCFM}
  479.     INLINE $205F, $4E90;
  480.     {$ENDC}
  481.  
  482. PROCEDURE CallQDJShieldCursorProc(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER; userRoutine: QDJShieldCursorUPP);
  483.     {$IFC NOT GENERATINGCFM}
  484.     INLINE $205F, $4E90;
  485.     {$ENDC}
  486.  
  487. TYPE
  488.     GrafPort = RECORD
  489.         device:                    INTEGER;
  490.         portBits:                BitMap;
  491.         portRect:                Rect;
  492.         visRgn:                    RgnHandle;
  493.         clipRgn:                RgnHandle;
  494.         bkPat:                    Pattern;
  495.         fillPat:                Pattern;
  496.         pnLoc:                    Point;
  497.         pnSize:                    Point;
  498.         pnMode:                    INTEGER;
  499.         pnPat:                    Pattern;
  500.         pnVis:                    INTEGER;
  501.         txFont:                    INTEGER;
  502.         txFace:                    Style;                                    {txFace is unpacked byte but push as short}
  503.         txMode:                    INTEGER;
  504.         txSize:                    INTEGER;
  505.         spExtra:                Fixed;
  506.         fgColor:                LONGINT;
  507.         bkColor:                LONGINT;
  508.         colrBit:                INTEGER;
  509.         patStretch:                INTEGER;
  510.         picSave:                Handle;
  511.         rgnSave:                Handle;
  512.         polySave:                Handle;
  513.         grafProcs:                QDProcsPtr;
  514.     END;
  515.  
  516.     GrafPtr = ^GrafPort;
  517.  
  518. {
  519.  *    This set of definitions "belongs" in Windows.
  520.  *    But, there is a circularity in the headers where Windows includes Controls and
  521.  *    Controls includes Windows. To break the circle, the information
  522.  *    needed by Controls is moved from Windows to Quickdraw.
  523.  }
  524.     WindowPtr = GrafPtr;
  525.  
  526. {
  527.     Set STRICT_WINDOWS to 1 to make sure your code 
  528.     doesn't access the window record directly
  529. }
  530. {$IFC UNDEFINED STRICT_WINDOWS }
  531. {$SETC STRICT_WINDOWS := 0}
  532. {$ENDC}
  533. {$IFC STRICT_WINDOWS }
  534.     WindowRef = Ptr;
  535.  
  536. {$ELSEC}
  537.     WindowRef = WindowPtr;
  538.  
  539. {$ENDC}
  540.     DragConstraint = UInt16;
  541.  
  542.  
  543. CONST
  544.     kNoConstraint                = 0;
  545.     kVerticalConstraint            = 1;
  546.     kHorizontalConstraint        = 2;
  547.  
  548. {
  549.  *    Here ends the list of things that "belong" in Windows.
  550.  }
  551.  
  552. TYPE
  553.     RGBColor = RECORD
  554.         red:                    INTEGER;                                {magnitude of red component}
  555.         green:                    INTEGER;                                {magnitude of green component}
  556.         blue:                    INTEGER;                                {magnitude of blue component}
  557.     END;
  558.  
  559.     RGBColorPtr = ^RGBColor;
  560.     RGBColorHdl = ^RGBColorPtr;
  561.  
  562.     DragGrayRgnProcPtr = ProcPtr;  { PROCEDURE DragGrayRgn; }
  563.     ColorSearchProcPtr = ProcPtr;  { FUNCTION ColorSearch(VAR rgb: RGBColor; VAR position: LONGINT): BOOLEAN; }
  564.     ColorComplementProcPtr = ProcPtr;  { FUNCTION ColorComplement(VAR rgb: RGBColor): BOOLEAN; }
  565.     DragGrayRgnUPP = UniversalProcPtr;
  566.     ColorSearchUPP = UniversalProcPtr;
  567.     ColorComplementUPP = UniversalProcPtr;
  568.  
  569. CONST
  570.     uppDragGrayRgnProcInfo = $00000000; { PROCEDURE ; }
  571.     uppColorSearchProcInfo = $000003D0; { FUNCTION (4 byte param, 4 byte param): 1 byte result; }
  572.     uppColorComplementProcInfo = $000000D0; { FUNCTION (4 byte param): 1 byte result; }
  573.  
  574. FUNCTION NewDragGrayRgnProc(userRoutine: DragGrayRgnProcPtr): DragGrayRgnUPP;
  575.     {$IFC NOT GENERATINGCFM }
  576.     INLINE $2E9F;
  577.     {$ENDC}
  578.  
  579. FUNCTION NewColorSearchProc(userRoutine: ColorSearchProcPtr): ColorSearchUPP;
  580.     {$IFC NOT GENERATINGCFM }
  581.     INLINE $2E9F;
  582.     {$ENDC}
  583.  
  584. FUNCTION NewColorComplementProc(userRoutine: ColorComplementProcPtr): ColorComplementUPP;
  585.     {$IFC NOT GENERATINGCFM }
  586.     INLINE $2E9F;
  587.     {$ENDC}
  588.  
  589. PROCEDURE CallDragGrayRgnProc(userRoutine: DragGrayRgnUPP);
  590.     {$IFC NOT GENERATINGCFM}
  591.     INLINE $205F, $4E90;
  592.     {$ENDC}
  593.  
  594. FUNCTION CallColorSearchProc(VAR rgb: RGBColor; VAR position: LONGINT; userRoutine: ColorSearchUPP): BOOLEAN;
  595.     {$IFC NOT GENERATINGCFM}
  596.     INLINE $205F, $4E90;
  597.     {$ENDC}
  598.  
  599. FUNCTION CallColorComplementProc(VAR rgb: RGBColor; userRoutine: ColorComplementUPP): BOOLEAN;
  600.     {$IFC NOT GENERATINGCFM}
  601.     INLINE $205F, $4E90;
  602.     {$ENDC}
  603.  
  604. TYPE
  605.     ColorSpec = RECORD
  606.         value:                    INTEGER;                                {index or other value}
  607.         rgb:                    RGBColor;                                {true color}
  608.     END;
  609.  
  610.     ColorSpecPtr = ^ColorSpec;
  611.  
  612.     CSpecArray = ARRAY [0..0] OF ColorSpec;
  613.  
  614.     xColorSpec = RECORD
  615.         value:                    INTEGER;                                {index or other value}
  616.         rgb:                    RGBColor;                                {true color}
  617.         xalpha:                    INTEGER;
  618.     END;
  619.  
  620.     xColorSpecPtr = ^xColorSpec;
  621.  
  622.     xCSpecArray = ARRAY [0..0] OF xColorSpec;
  623.  
  624.     ColorTable = RECORD
  625.         ctSeed:                    LONGINT;                                {unique identifier for table}
  626.         ctFlags:                INTEGER;                                {high bit: 0 = PixMap; 1 = device}
  627.         ctSize:                    INTEGER;                                {number of entries in CTTable}
  628.         ctTable:                CSpecArray;                                {array [0..0] of ColorSpec}
  629.     END;
  630.  
  631.     CTabPtr = ^ColorTable;
  632.     CTabHandle = ^CTabPtr;
  633.  
  634.     MatchRec = RECORD
  635.         red:                    INTEGER;
  636.         green:                    INTEGER;
  637.         blue:                    INTEGER;
  638.         matchData:                LONGINT;
  639.     END;
  640.  
  641.     PixMap = RECORD
  642.         baseAddr:                Ptr;                                    {pointer to pixels}
  643.         rowBytes:                INTEGER;                                {offset to next line}
  644.         bounds:                    Rect;                                    {encloses bitmap}
  645.         pmVersion:                INTEGER;                                {pixMap version number}
  646.         packType:                INTEGER;                                {defines packing format}
  647.         packSize:                LONGINT;                                {length of pixel data}
  648.         hRes:                    Fixed;                                    {horiz. resolution (ppi)}
  649.         vRes:                    Fixed;                                    {vert. resolution (ppi)}
  650.         pixelType:                INTEGER;                                {defines pixel type}
  651.         pixelSize:                INTEGER;                                {# bits in pixel}
  652.         cmpCount:                INTEGER;                                {# components in pixel}
  653.         cmpSize:                INTEGER;                                {# bits per component}
  654.         planeBytes:                LONGINT;                                {offset to next plane}
  655.         pmTable:                CTabHandle;                                {color map for this pixMap}
  656.         pmReserved:                LONGINT;                                {for future use. MUST BE 0}
  657.     END;
  658.  
  659.     PixMapPtr = ^PixMap;
  660.     PixMapHandle = ^PixMapPtr;
  661.  
  662.     PixPat = RECORD
  663.         patType:                INTEGER;                                {type of pattern}
  664.         patMap:                    PixMapHandle;                            {the pattern's pixMap}
  665.         patData:                Handle;                                    {pixmap's data}
  666.         patXData:                Handle;                                    {expanded Pattern data}
  667.         patXValid:                INTEGER;                                {flags whether expanded Pattern valid}
  668.         patXMap:                Handle;                                    {Handle to expanded Pattern data}
  669.         pat1Data:                Pattern;                                {old-Style pattern/RGB color}
  670.     END;
  671.  
  672.     PixPatPtr = ^PixPat;
  673.     PixPatHandle = ^PixPatPtr;
  674.  
  675.     CCrsr = RECORD
  676.         crsrType:                INTEGER;                                {type of cursor}
  677.         crsrMap:                PixMapHandle;                            {the cursor's pixmap}
  678.         crsrData:                Handle;                                    {cursor's data}
  679.         crsrXData:                Handle;                                    {expanded cursor data}
  680.         crsrXValid:                INTEGER;                                {depth of expanded data (0 if none)}
  681.         crsrXHandle:            Handle;                                    {future use}
  682.         crsr1Data:                Bits16;                                    {one-bit cursor}
  683.         crsrMask:                Bits16;                                    {cursor's mask}
  684.         crsrHotSpot:            Point;                                    {cursor's hotspot}
  685.         crsrXTable:                LONGINT;                                {private}
  686.         crsrID:                    LONGINT;                                {private}
  687.     END;
  688.  
  689.     CCrsrPtr = ^CCrsr;
  690.     CCrsrHandle = ^CCrsrPtr;
  691.  
  692. {$IFC OLDROUTINELOCATIONS }
  693.     CIcon = RECORD
  694.         iconPMap:                PixMap;                                    {the icon's pixMap}
  695.         iconMask:                BitMap;                                    {the icon's mask}
  696.         iconBMap:                BitMap;                                    {the icon's bitMap}
  697.         iconData:                Handle;                                    {the icon's data}
  698.         iconMaskData:            ARRAY [0..0] OF INTEGER;                {icon's mask and BitMap data}
  699.     END;
  700.  
  701.     CIconPtr = ^CIcon;
  702.     CIconHandle = ^CIconPtr;
  703.  
  704. {$ENDC}
  705.     GammaTbl = RECORD
  706.         gVersion:                INTEGER;                                {gamma version number}
  707.         gType:                    INTEGER;                                {gamma data type}
  708.         gFormulaSize:            INTEGER;                                {Formula data size}
  709.         gChanCnt:                INTEGER;                                {number of channels of data}
  710.         gDataCnt:                INTEGER;                                {number of values/channel}
  711.         gDataWidth:                INTEGER;                                {bits/corrected value (data packed to next larger byte size)}
  712.         gFormulaData:            ARRAY [0..0] OF INTEGER;                {data for formulas followed by gamma values}
  713.     END;
  714.  
  715.     GammaTblPtr = ^GammaTbl;
  716.     GammaTblHandle = ^GammaTblPtr;
  717.  
  718.     ITab = RECORD
  719.         iTabSeed:                LONGINT;                                {copy of CTSeed from source CTable}
  720.         iTabRes:                INTEGER;                                {bits/channel resolution of iTable}
  721.         iTTable:                ARRAY [0..0] OF SInt8; (* Byte *)        {byte colortable index values}
  722.     END;
  723.  
  724.     ITabPtr = ^ITab;
  725.     ITabHandle = ^ITabPtr;
  726.  
  727.     SProcRec = RECORD
  728.         nxtSrch:                Handle;                                    {SProcHndl Handle to next SProcRec}
  729.         srchProc:                ColorSearchUPP;                            {search procedure proc ptr}
  730.     END;
  731.  
  732.     SProcPtr = ^SProcRec;
  733.     SProcHndl = ^SProcPtr;
  734.  
  735.     CProcRec = RECORD
  736.         nxtComp:                Handle;                                    {CProcHndl Handle to next CProcRec}
  737.         compProc:                ColorComplementUPP;                        {complement procedure proc ptr}
  738.     END;
  739.  
  740.     CProcPtr = ^CProcRec;
  741.     CProcHndl = ^CProcPtr;
  742.  
  743.     GDevice = RECORD
  744.         gdRefNum:                INTEGER;                                {driver's unit number}
  745.         gdID:                    INTEGER;                                {client ID for search procs}
  746.         gdType:                    INTEGER;                                {fixed/CLUT/direct}
  747.         gdITable:                ITabHandle;                                {Handle to inverse lookup table}
  748.         gdResPref:                INTEGER;                                {preferred resolution of GDITable}
  749.         gdSearchProc:            SProcHndl;                                {search proc list head}
  750.         gdCompProc:                CProcHndl;                                {complement proc list}
  751.         gdFlags:                INTEGER;                                {grafDevice flags word}
  752.         gdPMap:                    PixMapHandle;                            {describing pixMap}
  753.         gdRefCon:                LONGINT;                                {reference value}
  754.         gdNextGD:                Handle;                                    {GDHandle Handle of next gDevice}
  755.         gdRect:                    Rect;                                    { device's bounds in global coordinates}
  756.         gdMode:                    LONGINT;                                {device's current mode}
  757.         gdCCBytes:                INTEGER;                                {depth of expanded cursor data}
  758.         gdCCDepth:                INTEGER;                                {depth of expanded cursor data}
  759.         gdCCXData:                Handle;                                    {Handle to cursor's expanded data}
  760.         gdCCXMask:                Handle;                                    {Handle to cursor's expanded mask}
  761.         gdReserved:                LONGINT;                                {future use. MUST BE 0}
  762.     END;
  763.  
  764.     GDPtr = ^GDevice;
  765.     GDHandle = ^GDPtr;
  766.  
  767.     GrafVars = RECORD
  768.         rgbOpColor:                RGBColor;                                {color for addPin  subPin and average}
  769.         rgbHiliteColor:            RGBColor;                                {color for hiliting}
  770.         pmFgColor:                Handle;                                    {palette Handle for foreground color}
  771.         pmFgIndex:                INTEGER;                                {index value for foreground}
  772.         pmBkColor:                Handle;                                    {palette Handle for background color}
  773.         pmBkIndex:                INTEGER;                                {index value for background}
  774.         pmFlags:                INTEGER;                                {flags for Palette Manager}
  775.     END;
  776.  
  777.     GVarPtr = ^GrafVars;
  778.     GVarHandle = ^GVarPtr;
  779.  
  780.     CQDProcs = RECORD
  781.         textProc:                QDTextUPP;
  782.         lineProc:                QDLineUPP;
  783.         rectProc:                QDRectUPP;
  784.         rRectProc:                QDRRectUPP;
  785.         ovalProc:                QDOvalUPP;
  786.         arcProc:                QDArcUPP;
  787.         polyProc:                QDPolyUPP;
  788.         rgnProc:                QDRgnUPP;
  789.         bitsProc:                QDBitsUPP;
  790.         commentProc:            QDCommentUPP;
  791.         txMeasProc:                QDTxMeasUPP;
  792.         getPicProc:                QDGetPicUPP;
  793.         putPicProc:                QDPutPicUPP;
  794.         opcodeProc:                QDOpcodeUPP;                            {fields added to QDProcs}
  795.         newProc1:                UniversalProcPtr;
  796.         newProc2:                UniversalProcPtr;
  797.         newProc3:                UniversalProcPtr;
  798.         newProc4:                UniversalProcPtr;
  799.         newProc5:                UniversalProcPtr;
  800.         newProc6:                UniversalProcPtr;
  801.     END;
  802.  
  803.     CQDProcsPtr = ^CQDProcs;
  804.  
  805.     CGrafPort = RECORD
  806.         device:                    INTEGER;
  807.         portPixMap:                PixMapHandle;                            {port's pixel map}
  808.         portVersion:            INTEGER;                                {high 2 bits always set}
  809.         grafVars:                Handle;                                    {Handle to more fields}
  810.         chExtra:                INTEGER;                                {character extra}
  811.         pnLocHFrac:                INTEGER;                                {pen fraction}
  812.         portRect:                Rect;
  813.         visRgn:                    RgnHandle;
  814.         clipRgn:                RgnHandle;
  815.         bkPixPat:                PixPatHandle;                            {background pattern}
  816.         rgbFgColor:                RGBColor;                                {RGB components of fg}
  817.         rgbBkColor:                RGBColor;                                {RGB components of bk}
  818.         pnLoc:                    Point;
  819.         pnSize:                    Point;
  820.         pnMode:                    INTEGER;
  821.         pnPixPat:                PixPatHandle;                            {pen's pattern}
  822.         fillPixPat:                PixPatHandle;                            {fill pattern}
  823.         pnVis:                    INTEGER;
  824.         txFont:                    INTEGER;
  825.         txFace:                    Style;                                    {txFace is unpacked byte  push as short}
  826.         txMode:                    INTEGER;
  827.         txSize:                    INTEGER;
  828.         spExtra:                Fixed;
  829.         fgColor:                LONGINT;
  830.         bkColor:                LONGINT;
  831.         colrBit:                INTEGER;
  832.         patStretch:                INTEGER;
  833.         picSave:                Handle;
  834.         rgnSave:                Handle;
  835.         polySave:                Handle;
  836.         grafProcs:                CQDProcsPtr;
  837.     END;
  838.  
  839.     CGrafPtr = ^CGrafPort;
  840.  
  841.     CWindowPtr = CGrafPtr;
  842.  
  843.     ReqListRec = RECORD
  844.         reqLSize:                INTEGER;                                {request list size}
  845.         reqLData:                ARRAY [0..0] OF INTEGER;                {request list data}
  846.     END;
  847.  
  848.     OpenCPicParams = RECORD
  849.         srcRect:                Rect;
  850.         hRes:                    Fixed;
  851.         vRes:                    Fixed;
  852.         version:                INTEGER;
  853.         reserved1:                INTEGER;
  854.         reserved2:                LONGINT;
  855.     END;
  856.  
  857.  
  858. CONST
  859.     kCursorImageMajorVersion    = $0001;
  860.     kCursorImageMinorVersion    = $0000;
  861.  
  862.  
  863. TYPE
  864.     CursorImageRec = RECORD
  865.         majorVersion:            UInt16;
  866.         minorVersion:            UInt16;
  867.         cursorPixMap:            PixMapHandle;
  868.         cursorBitMask:            BitMapHandle;
  869.     END;
  870.  
  871.     CursorImagePtr = ^CursorImageRec;
  872.  
  873.     DeviceLoopDrawingProcPtr = ProcPtr;  { PROCEDURE DeviceLoopDrawing(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT); }
  874.     DeviceLoopDrawingUPP = UniversalProcPtr;
  875.  
  876. CONST
  877.     uppDeviceLoopDrawingProcInfo = $00003E80; { PROCEDURE (2 byte param, 2 byte param, 4 byte param, 4 byte param); }
  878.  
  879. FUNCTION NewDeviceLoopDrawingProc(userRoutine: DeviceLoopDrawingProcPtr): DeviceLoopDrawingUPP;
  880.     {$IFC NOT GENERATINGCFM }
  881.     INLINE $2E9F;
  882.     {$ENDC}
  883.  
  884. PROCEDURE CallDeviceLoopDrawingProc(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT; userRoutine: DeviceLoopDrawingUPP);
  885.     {$IFC NOT GENERATINGCFM}
  886.     INLINE $205F, $4E90;
  887.     {$ENDC}
  888.  
  889. TYPE
  890.     QDGlobals = RECORD
  891.         privates:                PACKED ARRAY [0..75] OF CHAR;
  892.         randSeed:                LONGINT;
  893.         screenBits:                BitMap;
  894.         arrow:                    Cursor;
  895.         dkGray:                    Pattern;
  896.         ltGray:                    Pattern;
  897.         gray:                    Pattern;
  898.         black:                    Pattern;
  899.         white:                    Pattern;
  900.         thePort:                GrafPtr;
  901.     END;
  902.  
  903.     QDGlobalsPtr = ^QDGlobals;
  904.     QDGlobalsHdl = ^QDGlobalsPtr;
  905.  
  906.  
  907. { To be in sync with the C interface to QuickDraw globals, pascal code must now }
  908. { qualify the QuickDraw globals with “qd.” (e.g. InitGraf(@qd.thePort);  )       }
  909. VAR
  910.     {$PUSH}
  911.     {$J+}
  912.     qd: QDGlobals;
  913.     {$POP}
  914.  
  915. PROCEDURE InitGraf(globalPtr: UNIV Ptr);
  916.     {$IFC NOT GENERATINGCFM}
  917.     INLINE $A86E;
  918.     {$ENDC}
  919. PROCEDURE OpenPort(port: GrafPtr);
  920.     {$IFC NOT GENERATINGCFM}
  921.     INLINE $A86F;
  922.     {$ENDC}
  923. PROCEDURE InitPort(port: GrafPtr);
  924.     {$IFC NOT GENERATINGCFM}
  925.     INLINE $A86D;
  926.     {$ENDC}
  927. PROCEDURE ClosePort(port: GrafPtr);
  928.     {$IFC NOT GENERATINGCFM}
  929.     INLINE $A87D;
  930.     {$ENDC}
  931. PROCEDURE SetPort(port: GrafPtr);
  932.     {$IFC NOT GENERATINGCFM}
  933.     INLINE $A873;
  934.     {$ENDC}
  935. PROCEDURE GetPort(VAR port: GrafPtr);
  936.     {$IFC NOT GENERATINGCFM}
  937.     INLINE $A874;
  938.     {$ENDC}
  939. PROCEDURE GrafDevice(device: INTEGER);
  940.     {$IFC NOT GENERATINGCFM}
  941.     INLINE $A872;
  942.     {$ENDC}
  943. PROCEDURE SetPortBits({CONST}VAR bm: BitMap);
  944.     {$IFC NOT GENERATINGCFM}
  945.     INLINE $A875;
  946.     {$ENDC}
  947. PROCEDURE PortSize(width: INTEGER; height: INTEGER);
  948.     {$IFC NOT GENERATINGCFM}
  949.     INLINE $A876;
  950.     {$ENDC}
  951. PROCEDURE MovePortTo(leftGlobal: INTEGER; topGlobal: INTEGER);
  952.     {$IFC NOT GENERATINGCFM}
  953.     INLINE $A877;
  954.     {$ENDC}
  955. PROCEDURE SetOrigin(h: INTEGER; v: INTEGER);
  956.     {$IFC NOT GENERATINGCFM}
  957.     INLINE $A878;
  958.     {$ENDC}
  959. PROCEDURE SetClip(rgn: RgnHandle);
  960.     {$IFC NOT GENERATINGCFM}
  961.     INLINE $A879;
  962.     {$ENDC}
  963. PROCEDURE GetClip(rgn: RgnHandle);
  964.     {$IFC NOT GENERATINGCFM}
  965.     INLINE $A87A;
  966.     {$ENDC}
  967. PROCEDURE ClipRect({CONST}VAR r: Rect);
  968.     {$IFC NOT GENERATINGCFM}
  969.     INLINE $A87B;
  970.     {$ENDC}
  971. PROCEDURE BackPat({CONST}VAR pat: Pattern);
  972.     {$IFC NOT GENERATINGCFM}
  973.     INLINE $A87C;
  974.     {$ENDC}
  975. PROCEDURE InitCursor;
  976.     {$IFC NOT GENERATINGCFM}
  977.     INLINE $A850;
  978.     {$ENDC}
  979. PROCEDURE SetCursor({CONST}VAR crsr: Cursor);
  980.     {$IFC NOT GENERATINGCFM}
  981.     INLINE $A851;
  982.     {$ENDC}
  983. PROCEDURE HideCursor;
  984.     {$IFC NOT GENERATINGCFM}
  985.     INLINE $A852;
  986.     {$ENDC}
  987. PROCEDURE ShowCursor;
  988.     {$IFC NOT GENERATINGCFM}
  989.     INLINE $A853;
  990.     {$ENDC}
  991. PROCEDURE ObscureCursor;
  992.     {$IFC NOT GENERATINGCFM}
  993.     INLINE $A856;
  994.     {$ENDC}
  995. PROCEDURE HidePen;
  996.     {$IFC NOT GENERATINGCFM}
  997.     INLINE $A896;
  998.     {$ENDC}
  999. PROCEDURE ShowPen;
  1000.     {$IFC NOT GENERATINGCFM}
  1001.     INLINE $A897;
  1002.     {$ENDC}
  1003. PROCEDURE GetPen(VAR pt: Point);
  1004.     {$IFC NOT GENERATINGCFM}
  1005.     INLINE $A89A;
  1006.     {$ENDC}
  1007. PROCEDURE GetPenState(VAR pnState: PenState);
  1008.     {$IFC NOT GENERATINGCFM}
  1009.     INLINE $A898;
  1010.     {$ENDC}
  1011. PROCEDURE SetPenState({CONST}VAR pnState: PenState);
  1012.     {$IFC NOT GENERATINGCFM}
  1013.     INLINE $A899;
  1014.     {$ENDC}
  1015. PROCEDURE PenSize(width: INTEGER; height: INTEGER);
  1016.     {$IFC NOT GENERATINGCFM}
  1017.     INLINE $A89B;
  1018.     {$ENDC}
  1019. PROCEDURE PenMode(mode: INTEGER);
  1020.     {$IFC NOT GENERATINGCFM}
  1021.     INLINE $A89C;
  1022.     {$ENDC}
  1023. PROCEDURE PenPat({CONST}VAR pat: Pattern);
  1024.     {$IFC NOT GENERATINGCFM}
  1025.     INLINE $A89D;
  1026.     {$ENDC}
  1027. PROCEDURE PenNormal;
  1028.     {$IFC NOT GENERATINGCFM}
  1029.     INLINE $A89E;
  1030.     {$ENDC}
  1031. PROCEDURE MoveTo(h: INTEGER; v: INTEGER);
  1032.     {$IFC NOT GENERATINGCFM}
  1033.     INLINE $A893;
  1034.     {$ENDC}
  1035. PROCEDURE Move(dh: INTEGER; dv: INTEGER);
  1036.     {$IFC NOT GENERATINGCFM}
  1037.     INLINE $A894;
  1038.     {$ENDC}
  1039. PROCEDURE LineTo(h: INTEGER; v: INTEGER);
  1040.     {$IFC NOT GENERATINGCFM}
  1041.     INLINE $A891;
  1042.     {$ENDC}
  1043. PROCEDURE Line(dh: INTEGER; dv: INTEGER);
  1044.     {$IFC NOT GENERATINGCFM}
  1045.     INLINE $A892;
  1046.     {$ENDC}
  1047. PROCEDURE ForeColor(color: LONGINT);
  1048.     {$IFC NOT GENERATINGCFM}
  1049.     INLINE $A862;
  1050.     {$ENDC}
  1051. PROCEDURE BackColor(color: LONGINT);
  1052.     {$IFC NOT GENERATINGCFM}
  1053.     INLINE $A863;
  1054.     {$ENDC}
  1055. PROCEDURE ColorBit(whichBit: INTEGER);
  1056.     {$IFC NOT GENERATINGCFM}
  1057.     INLINE $A864;
  1058.     {$ENDC}
  1059. PROCEDURE SetRect(VAR r: Rect; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1060.     {$IFC NOT GENERATINGCFM}
  1061.     INLINE $A8A7;
  1062.     {$ENDC}
  1063. PROCEDURE OffsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  1064.     {$IFC NOT GENERATINGCFM}
  1065.     INLINE $A8A8;
  1066.     {$ENDC}
  1067. PROCEDURE InsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  1068.     {$IFC NOT GENERATINGCFM}
  1069.     INLINE $A8A9;
  1070.     {$ENDC}
  1071. FUNCTION SectRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect): BOOLEAN;
  1072.     {$IFC NOT GENERATINGCFM}
  1073.     INLINE $A8AA;
  1074.     {$ENDC}
  1075. PROCEDURE UnionRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect);
  1076.     {$IFC NOT GENERATINGCFM}
  1077.     INLINE $A8AB;
  1078.     {$ENDC}
  1079. FUNCTION EqualRect({CONST}VAR rect1: Rect; {CONST}VAR rect2: Rect): BOOLEAN;
  1080.     {$IFC NOT GENERATINGCFM}
  1081.     INLINE $A8A6;
  1082.     {$ENDC}
  1083. FUNCTION EmptyRect({CONST}VAR r: Rect): BOOLEAN;
  1084.     {$IFC NOT GENERATINGCFM}
  1085.     INLINE $A8AE;
  1086.     {$ENDC}
  1087. PROCEDURE FrameRect({CONST}VAR r: Rect);
  1088.     {$IFC NOT GENERATINGCFM}
  1089.     INLINE $A8A1;
  1090.     {$ENDC}
  1091. PROCEDURE PaintRect({CONST}VAR r: Rect);
  1092.     {$IFC NOT GENERATINGCFM}
  1093.     INLINE $A8A2;
  1094.     {$ENDC}
  1095. PROCEDURE EraseRect({CONST}VAR r: Rect);
  1096.     {$IFC NOT GENERATINGCFM}
  1097.     INLINE $A8A3;
  1098.     {$ENDC}
  1099. PROCEDURE InvertRect({CONST}VAR r: Rect);
  1100.     {$IFC NOT GENERATINGCFM}
  1101.     INLINE $A8A4;
  1102.     {$ENDC}
  1103. PROCEDURE FillRect({CONST}VAR r: Rect; {CONST}VAR pat: Pattern);
  1104.     {$IFC NOT GENERATINGCFM}
  1105.     INLINE $A8A5;
  1106.     {$ENDC}
  1107. PROCEDURE FrameOval({CONST}VAR r: Rect);
  1108.     {$IFC NOT GENERATINGCFM}
  1109.     INLINE $A8B7;
  1110.     {$ENDC}
  1111. PROCEDURE PaintOval({CONST}VAR r: Rect);
  1112.     {$IFC NOT GENERATINGCFM}
  1113.     INLINE $A8B8;
  1114.     {$ENDC}
  1115. PROCEDURE EraseOval({CONST}VAR r: Rect);
  1116.     {$IFC NOT GENERATINGCFM}
  1117.     INLINE $A8B9;
  1118.     {$ENDC}
  1119. PROCEDURE InvertOval({CONST}VAR r: Rect);
  1120.     {$IFC NOT GENERATINGCFM}
  1121.     INLINE $A8BA;
  1122.     {$ENDC}
  1123. PROCEDURE FillOval({CONST}VAR r: Rect; {CONST}VAR pat: Pattern);
  1124.     {$IFC NOT GENERATINGCFM}
  1125.     INLINE $A8BB;
  1126.     {$ENDC}
  1127. PROCEDURE FrameRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1128.     {$IFC NOT GENERATINGCFM}
  1129.     INLINE $A8B0;
  1130.     {$ENDC}
  1131. PROCEDURE PaintRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1132.     {$IFC NOT GENERATINGCFM}
  1133.     INLINE $A8B1;
  1134.     {$ENDC}
  1135. PROCEDURE EraseRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1136.     {$IFC NOT GENERATINGCFM}
  1137.     INLINE $A8B2;
  1138.     {$ENDC}
  1139. PROCEDURE InvertRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1140.     {$IFC NOT GENERATINGCFM}
  1141.     INLINE $A8B3;
  1142.     {$ENDC}
  1143. PROCEDURE FillRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; {CONST}VAR pat: Pattern);
  1144.     {$IFC NOT GENERATINGCFM}
  1145.     INLINE $A8B4;
  1146.     {$ENDC}
  1147. PROCEDURE FrameArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1148.     {$IFC NOT GENERATINGCFM}
  1149.     INLINE $A8BE;
  1150.     {$ENDC}
  1151. PROCEDURE PaintArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1152.     {$IFC NOT GENERATINGCFM}
  1153.     INLINE $A8BF;
  1154.     {$ENDC}
  1155. PROCEDURE EraseArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1156.     {$IFC NOT GENERATINGCFM}
  1157.     INLINE $A8C0;
  1158.     {$ENDC}
  1159. PROCEDURE InvertArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1160.     {$IFC NOT GENERATINGCFM}
  1161.     INLINE $A8C1;
  1162.     {$ENDC}
  1163. PROCEDURE FillArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; {CONST}VAR pat: Pattern);
  1164.     {$IFC NOT GENERATINGCFM}
  1165.     INLINE $A8C2;
  1166.     {$ENDC}
  1167. FUNCTION NewRgn: RgnHandle;
  1168.     {$IFC NOT GENERATINGCFM}
  1169.     INLINE $A8D8;
  1170.     {$ENDC}
  1171. PROCEDURE OpenRgn;
  1172.     {$IFC NOT GENERATINGCFM}
  1173.     INLINE $A8DA;
  1174.     {$ENDC}
  1175. PROCEDURE CloseRgn(dstRgn: RgnHandle);
  1176.     {$IFC NOT GENERATINGCFM}
  1177.     INLINE $A8DB;
  1178.     {$ENDC}
  1179. {$IFC NOT SystemSevenOrLater }
  1180. FUNCTION BitMapToRegionGlue(region: RgnHandle; {CONST}VAR bMap: BitMap): OSErr;
  1181. {$ENDC}
  1182. FUNCTION BitMapToRegion(region: RgnHandle; {CONST}VAR bMap: BitMap): OSErr;
  1183.     {$IFC NOT GENERATINGCFM}
  1184.     INLINE $A8D7;
  1185.     {$ENDC}
  1186. PROCEDURE DisposeRgn(rgn: RgnHandle);
  1187.     {$IFC NOT GENERATINGCFM}
  1188.     INLINE $A8D9;
  1189.     {$ENDC}
  1190. PROCEDURE CopyRgn(srcRgn: RgnHandle; dstRgn: RgnHandle);
  1191.     {$IFC NOT GENERATINGCFM}
  1192.     INLINE $A8DC;
  1193.     {$ENDC}
  1194. PROCEDURE SetEmptyRgn(rgn: RgnHandle);
  1195.     {$IFC NOT GENERATINGCFM}
  1196.     INLINE $A8DD;
  1197.     {$ENDC}
  1198. PROCEDURE SetRectRgn(rgn: RgnHandle; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1199.     {$IFC NOT GENERATINGCFM}
  1200.     INLINE $A8DE;
  1201.     {$ENDC}
  1202. PROCEDURE RectRgn(rgn: RgnHandle; {CONST}VAR r: Rect);
  1203.     {$IFC NOT GENERATINGCFM}
  1204.     INLINE $A8DF;
  1205.     {$ENDC}
  1206. PROCEDURE OffsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1207.     {$IFC NOT GENERATINGCFM}
  1208.     INLINE $A8E0;
  1209.     {$ENDC}
  1210. PROCEDURE InsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1211.     {$IFC NOT GENERATINGCFM}
  1212.     INLINE $A8E1;
  1213.     {$ENDC}
  1214. PROCEDURE SectRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1215.     {$IFC NOT GENERATINGCFM}
  1216.     INLINE $A8E4;
  1217.     {$ENDC}
  1218. PROCEDURE UnionRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1219.     {$IFC NOT GENERATINGCFM}
  1220.     INLINE $A8E5;
  1221.     {$ENDC}
  1222. PROCEDURE DiffRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1223.     {$IFC NOT GENERATINGCFM}
  1224.     INLINE $A8E6;
  1225.     {$ENDC}
  1226. PROCEDURE XorRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1227.     {$IFC NOT GENERATINGCFM}
  1228.     INLINE $A8E7;
  1229.     {$ENDC}
  1230. FUNCTION RectInRgn({CONST}VAR r: Rect; rgn: RgnHandle): BOOLEAN;
  1231.     {$IFC NOT GENERATINGCFM}
  1232.     INLINE $A8E9;
  1233.     {$ENDC}
  1234. FUNCTION EqualRgn(rgnA: RgnHandle; rgnB: RgnHandle): BOOLEAN;
  1235.     {$IFC NOT GENERATINGCFM}
  1236.     INLINE $A8E3;
  1237.     {$ENDC}
  1238. FUNCTION EmptyRgn(rgn: RgnHandle): BOOLEAN;
  1239.     {$IFC NOT GENERATINGCFM}
  1240.     INLINE $A8E2;
  1241.     {$ENDC}
  1242. PROCEDURE FrameRgn(rgn: RgnHandle);
  1243.     {$IFC NOT GENERATINGCFM}
  1244.     INLINE $A8D2;
  1245.     {$ENDC}
  1246. PROCEDURE PaintRgn(rgn: RgnHandle);
  1247.     {$IFC NOT GENERATINGCFM}
  1248.     INLINE $A8D3;
  1249.     {$ENDC}
  1250. PROCEDURE EraseRgn(rgn: RgnHandle);
  1251.     {$IFC NOT GENERATINGCFM}
  1252.     INLINE $A8D4;
  1253.     {$ENDC}
  1254. PROCEDURE InvertRgn(rgn: RgnHandle);
  1255.     {$IFC NOT GENERATINGCFM}
  1256.     INLINE $A8D5;
  1257.     {$ENDC}
  1258. PROCEDURE FillRgn(rgn: RgnHandle; {CONST}VAR pat: Pattern);
  1259.     {$IFC NOT GENERATINGCFM}
  1260.     INLINE $A8D6;
  1261.     {$ENDC}
  1262. PROCEDURE ScrollRect({CONST}VAR r: Rect; dh: INTEGER; dv: INTEGER; updateRgn: RgnHandle);
  1263.     {$IFC NOT GENERATINGCFM}
  1264.     INLINE $A8EF;
  1265.     {$ENDC}
  1266. PROCEDURE CopyBits({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1267.     {$IFC NOT GENERATINGCFM}
  1268.     INLINE $A8EC;
  1269.     {$ENDC}
  1270. PROCEDURE SeedFill(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER; seedH: INTEGER; seedV: INTEGER);
  1271.     {$IFC NOT GENERATINGCFM}
  1272.     INLINE $A839;
  1273.     {$ENDC}
  1274. PROCEDURE CalcMask(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER);
  1275.     {$IFC NOT GENERATINGCFM}
  1276.     INLINE $A838;
  1277.     {$ENDC}
  1278. PROCEDURE CopyMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect);
  1279.     {$IFC NOT GENERATINGCFM}
  1280.     INLINE $A817;
  1281.     {$ENDC}
  1282. FUNCTION OpenPicture({CONST}VAR picFrame: Rect): PicHandle;
  1283.     {$IFC NOT GENERATINGCFM}
  1284.     INLINE $A8F3;
  1285.     {$ENDC}
  1286. PROCEDURE PicComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1287.     {$IFC NOT GENERATINGCFM}
  1288.     INLINE $A8F2;
  1289.     {$ENDC}
  1290. PROCEDURE ClosePicture;
  1291.     {$IFC NOT GENERATINGCFM}
  1292.     INLINE $A8F4;
  1293.     {$ENDC}
  1294. PROCEDURE DrawPicture(myPicture: PicHandle; {CONST}VAR dstRect: Rect);
  1295.     {$IFC NOT GENERATINGCFM}
  1296.     INLINE $A8F6;
  1297.     {$ENDC}
  1298. PROCEDURE KillPicture(myPicture: PicHandle);
  1299.     {$IFC NOT GENERATINGCFM}
  1300.     INLINE $A8F5;
  1301.     {$ENDC}
  1302. FUNCTION OpenPoly: PolyHandle;
  1303.     {$IFC NOT GENERATINGCFM}
  1304.     INLINE $A8CB;
  1305.     {$ENDC}
  1306. PROCEDURE ClosePoly;
  1307.     {$IFC NOT GENERATINGCFM}
  1308.     INLINE $A8CC;
  1309.     {$ENDC}
  1310. PROCEDURE KillPoly(poly: PolyHandle);
  1311.     {$IFC NOT GENERATINGCFM}
  1312.     INLINE $A8CD;
  1313.     {$ENDC}
  1314. PROCEDURE OffsetPoly(poly: PolyHandle; dh: INTEGER; dv: INTEGER);
  1315.     {$IFC NOT GENERATINGCFM}
  1316.     INLINE $A8CE;
  1317.     {$ENDC}
  1318. PROCEDURE FramePoly(poly: PolyHandle);
  1319.     {$IFC NOT GENERATINGCFM}
  1320.     INLINE $A8C6;
  1321.     {$ENDC}
  1322. PROCEDURE PaintPoly(poly: PolyHandle);
  1323.     {$IFC NOT GENERATINGCFM}
  1324.     INLINE $A8C7;
  1325.     {$ENDC}
  1326. PROCEDURE ErasePoly(poly: PolyHandle);
  1327.     {$IFC NOT GENERATINGCFM}
  1328.     INLINE $A8C8;
  1329.     {$ENDC}
  1330. PROCEDURE InvertPoly(poly: PolyHandle);
  1331.     {$IFC NOT GENERATINGCFM}
  1332.     INLINE $A8C9;
  1333.     {$ENDC}
  1334. PROCEDURE FillPoly(poly: PolyHandle; {CONST}VAR pat: Pattern);
  1335.     {$IFC NOT GENERATINGCFM}
  1336.     INLINE $A8CA;
  1337.     {$ENDC}
  1338. PROCEDURE SetPt(VAR pt: Point; h: INTEGER; v: INTEGER);
  1339.     {$IFC NOT GENERATINGCFM}
  1340.     INLINE $A880;
  1341.     {$ENDC}
  1342. PROCEDURE LocalToGlobal(VAR pt: Point);
  1343.     {$IFC NOT GENERATINGCFM}
  1344.     INLINE $A870;
  1345.     {$ENDC}
  1346. PROCEDURE GlobalToLocal(VAR pt: Point);
  1347.     {$IFC NOT GENERATINGCFM}
  1348.     INLINE $A871;
  1349.     {$ENDC}
  1350. FUNCTION Random: INTEGER;
  1351.     {$IFC NOT GENERATINGCFM}
  1352.     INLINE $A861;
  1353.     {$ENDC}
  1354. PROCEDURE StuffHex(thingPtr: UNIV Ptr; s: ConstStr255Param);
  1355.     {$IFC NOT GENERATINGCFM}
  1356.     INLINE $A866;
  1357.     {$ENDC}
  1358. FUNCTION GetPixel(h: INTEGER; v: INTEGER): BOOLEAN;
  1359.     {$IFC NOT GENERATINGCFM}
  1360.     INLINE $A865;
  1361.     {$ENDC}
  1362. PROCEDURE ScalePt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1363.     {$IFC NOT GENERATINGCFM}
  1364.     INLINE $A8F8;
  1365.     {$ENDC}
  1366. PROCEDURE MapPt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1367.     {$IFC NOT GENERATINGCFM}
  1368.     INLINE $A8F9;
  1369.     {$ENDC}
  1370. PROCEDURE MapRect(VAR r: Rect; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1371.     {$IFC NOT GENERATINGCFM}
  1372.     INLINE $A8FA;
  1373.     {$ENDC}
  1374. PROCEDURE MapRgn(rgn: RgnHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1375.     {$IFC NOT GENERATINGCFM}
  1376.     INLINE $A8FB;
  1377.     {$ENDC}
  1378. PROCEDURE MapPoly(poly: PolyHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1379.     {$IFC NOT GENERATINGCFM}
  1380.     INLINE $A8FC;
  1381.     {$ENDC}
  1382. PROCEDURE SetStdProcs(VAR procs: QDProcs);
  1383.     {$IFC NOT GENERATINGCFM}
  1384.     INLINE $A8EA;
  1385.     {$ENDC}
  1386. PROCEDURE StdRect(verb: ByteParameter; {CONST}VAR r: Rect);
  1387.     {$IFC NOT GENERATINGCFM}
  1388.     INLINE $A8A0;
  1389.     {$ENDC}
  1390. PROCEDURE StdRRect(verb: ByteParameter; {CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1391.     {$IFC NOT GENERATINGCFM}
  1392.     INLINE $A8AF;
  1393.     {$ENDC}
  1394. PROCEDURE StdOval(verb: ByteParameter; {CONST}VAR r: Rect);
  1395.     {$IFC NOT GENERATINGCFM}
  1396.     INLINE $A8B6;
  1397.     {$ENDC}
  1398. PROCEDURE StdArc(verb: ByteParameter; {CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1399.     {$IFC NOT GENERATINGCFM}
  1400.     INLINE $A8BD;
  1401.     {$ENDC}
  1402. PROCEDURE StdPoly(verb: ByteParameter; poly: PolyHandle);
  1403.     {$IFC NOT GENERATINGCFM}
  1404.     INLINE $A8C5;
  1405.     {$ENDC}
  1406. PROCEDURE StdRgn(verb: ByteParameter; rgn: RgnHandle);
  1407.     {$IFC NOT GENERATINGCFM}
  1408.     INLINE $A8D1;
  1409.     {$ENDC}
  1410. PROCEDURE StdBits({CONST}VAR srcBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1411.     {$IFC NOT GENERATINGCFM}
  1412.     INLINE $A8EB;
  1413.     {$ENDC}
  1414. PROCEDURE StdComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1415.     {$IFC NOT GENERATINGCFM}
  1416.     INLINE $A8F1;
  1417.     {$ENDC}
  1418. PROCEDURE StdGetPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1419.     {$IFC NOT GENERATINGCFM}
  1420.     INLINE $A8EE;
  1421.     {$ENDC}
  1422. PROCEDURE StdPutPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1423.     {$IFC NOT GENERATINGCFM}
  1424.     INLINE $A8F0;
  1425.     {$ENDC}
  1426. PROCEDURE AddPt(src: Point; VAR dst: Point);
  1427.     {$IFC NOT GENERATINGCFM}
  1428.     INLINE $A87E;
  1429.     {$ENDC}
  1430. FUNCTION EqualPt(pt1: Point; pt2: Point): BOOLEAN;
  1431.     {$IFC NOT GENERATINGCFM}
  1432.     INLINE $A881;
  1433.     {$ENDC}
  1434. FUNCTION PtInRect(pt: Point; {CONST}VAR r: Rect): BOOLEAN;
  1435.     {$IFC NOT GENERATINGCFM}
  1436.     INLINE $A8AD;
  1437.     {$ENDC}
  1438. PROCEDURE Pt2Rect(pt1: Point; pt2: Point; VAR dstRect: Rect);
  1439.     {$IFC NOT GENERATINGCFM}
  1440.     INLINE $A8AC;
  1441.     {$ENDC}
  1442. PROCEDURE PtToAngle({CONST}VAR r: Rect; pt: Point; VAR angle: INTEGER);
  1443.     {$IFC NOT GENERATINGCFM}
  1444.     INLINE $A8C3;
  1445.     {$ENDC}
  1446. PROCEDURE SubPt(src: Point; VAR dst: Point);
  1447.     {$IFC NOT GENERATINGCFM}
  1448.     INLINE $A87F;
  1449.     {$ENDC}
  1450. FUNCTION PtInRgn(pt: Point; rgn: RgnHandle): BOOLEAN;
  1451.     {$IFC NOT GENERATINGCFM}
  1452.     INLINE $A8E8;
  1453.     {$ENDC}
  1454. PROCEDURE StdLine(newPt: Point);
  1455.     {$IFC NOT GENERATINGCFM}
  1456.     INLINE $A890;
  1457.     {$ENDC}
  1458. PROCEDURE OpenCPort(port: CGrafPtr);
  1459.     {$IFC NOT GENERATINGCFM}
  1460.     INLINE $AA00;
  1461.     {$ENDC}
  1462. PROCEDURE InitCPort(port: CGrafPtr);
  1463.     {$IFC NOT GENERATINGCFM}
  1464.     INLINE $AA01;
  1465.     {$ENDC}
  1466. PROCEDURE CloseCPort(port: CGrafPtr);
  1467.     {$IFC NOT GENERATINGCFM}
  1468.     INLINE $A87D;
  1469.     {$ENDC}
  1470. FUNCTION NewPixMap: PixMapHandle;
  1471.     {$IFC NOT GENERATINGCFM}
  1472.     INLINE $AA03;
  1473.     {$ENDC}
  1474. PROCEDURE DisposePixMap(pm: PixMapHandle);
  1475.     {$IFC NOT GENERATINGCFM}
  1476.     INLINE $AA04;
  1477.     {$ENDC}
  1478. PROCEDURE CopyPixMap(srcPM: PixMapHandle; dstPM: PixMapHandle);
  1479.     {$IFC NOT GENERATINGCFM}
  1480.     INLINE $AA05;
  1481.     {$ENDC}
  1482. FUNCTION NewPixPat: PixPatHandle;
  1483.     {$IFC NOT GENERATINGCFM}
  1484.     INLINE $AA07;
  1485.     {$ENDC}
  1486. PROCEDURE DisposePixPat(pp: PixPatHandle);
  1487.     {$IFC NOT GENERATINGCFM}
  1488.     INLINE $AA08;
  1489.     {$ENDC}
  1490. PROCEDURE CopyPixPat(srcPP: PixPatHandle; dstPP: PixPatHandle);
  1491.     {$IFC NOT GENERATINGCFM}
  1492.     INLINE $AA09;
  1493.     {$ENDC}
  1494. PROCEDURE PenPixPat(pp: PixPatHandle);
  1495.     {$IFC NOT GENERATINGCFM}
  1496.     INLINE $AA0A;
  1497.     {$ENDC}
  1498. PROCEDURE BackPixPat(pp: PixPatHandle);
  1499.     {$IFC NOT GENERATINGCFM}
  1500.     INLINE $AA0B;
  1501.     {$ENDC}
  1502. FUNCTION GetPixPat(patID: INTEGER): PixPatHandle;
  1503.     {$IFC NOT GENERATINGCFM}
  1504.     INLINE $AA0C;
  1505.     {$ENDC}
  1506. PROCEDURE MakeRGBPat(pp: PixPatHandle; {CONST}VAR myColor: RGBColor);
  1507.     {$IFC NOT GENERATINGCFM}
  1508.     INLINE $AA0D;
  1509.     {$ENDC}
  1510. PROCEDURE FillCRect({CONST}VAR r: Rect; pp: PixPatHandle);
  1511.     {$IFC NOT GENERATINGCFM}
  1512.     INLINE $AA0E;
  1513.     {$ENDC}
  1514. PROCEDURE FillCOval({CONST}VAR r: Rect; pp: PixPatHandle);
  1515.     {$IFC NOT GENERATINGCFM}
  1516.     INLINE $AA0F;
  1517.     {$ENDC}
  1518. PROCEDURE FillCRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; pp: PixPatHandle);
  1519.     {$IFC NOT GENERATINGCFM}
  1520.     INLINE $AA10;
  1521.     {$ENDC}
  1522. PROCEDURE FillCArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; pp: PixPatHandle);
  1523.     {$IFC NOT GENERATINGCFM}
  1524.     INLINE $AA11;
  1525.     {$ENDC}
  1526. PROCEDURE FillCRgn(rgn: RgnHandle; pp: PixPatHandle);
  1527.     {$IFC NOT GENERATINGCFM}
  1528.     INLINE $AA12;
  1529.     {$ENDC}
  1530. PROCEDURE FillCPoly(poly: PolyHandle; pp: PixPatHandle);
  1531.     {$IFC NOT GENERATINGCFM}
  1532.     INLINE $AA13;
  1533.     {$ENDC}
  1534. PROCEDURE RGBForeColor({CONST}VAR color: RGBColor);
  1535.     {$IFC NOT GENERATINGCFM}
  1536.     INLINE $AA14;
  1537.     {$ENDC}
  1538. PROCEDURE RGBBackColor({CONST}VAR color: RGBColor);
  1539.     {$IFC NOT GENERATINGCFM}
  1540.     INLINE $AA15;
  1541.     {$ENDC}
  1542. PROCEDURE SetCPixel(h: INTEGER; v: INTEGER; {CONST}VAR cPix: RGBColor);
  1543.     {$IFC NOT GENERATINGCFM}
  1544.     INLINE $AA16;
  1545.     {$ENDC}
  1546. PROCEDURE SetPortPix(pm: PixMapHandle);
  1547.     {$IFC NOT GENERATINGCFM}
  1548.     INLINE $AA06;
  1549.     {$ENDC}
  1550. PROCEDURE GetCPixel(h: INTEGER; v: INTEGER; VAR cPix: RGBColor);
  1551.     {$IFC NOT GENERATINGCFM}
  1552.     INLINE $AA17;
  1553.     {$ENDC}
  1554. PROCEDURE GetForeColor(VAR color: RGBColor);
  1555.     {$IFC NOT GENERATINGCFM}
  1556.     INLINE $AA19;
  1557.     {$ENDC}
  1558. PROCEDURE GetBackColor(VAR color: RGBColor);
  1559.     {$IFC NOT GENERATINGCFM}
  1560.     INLINE $AA1A;
  1561.     {$ENDC}
  1562. PROCEDURE SeedCFill({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; seedH: INTEGER; seedV: INTEGER; matchProc: ColorSearchUPP; matchData: LONGINT);
  1563.     {$IFC NOT GENERATINGCFM}
  1564.     INLINE $AA50;
  1565.     {$ENDC}
  1566. PROCEDURE CalcCMask({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; {CONST}VAR seedRGB: RGBColor; matchProc: ColorSearchUPP; matchData: LONGINT);
  1567.     {$IFC NOT GENERATINGCFM}
  1568.     INLINE $AA4F;
  1569.     {$ENDC}
  1570. FUNCTION OpenCPicture({CONST}VAR newHeader: OpenCPicParams): PicHandle;
  1571.     {$IFC NOT GENERATINGCFM}
  1572.     INLINE $AA20;
  1573.     {$ENDC}
  1574. PROCEDURE OpColor({CONST}VAR color: RGBColor);
  1575.     {$IFC NOT GENERATINGCFM}
  1576.     INLINE $AA21;
  1577.     {$ENDC}
  1578. PROCEDURE HiliteColor({CONST}VAR color: RGBColor);
  1579.     {$IFC NOT GENERATINGCFM}
  1580.     INLINE $AA22;
  1581.     {$ENDC}
  1582. PROCEDURE DisposeCTable(cTable: CTabHandle);
  1583.     {$IFC NOT GENERATINGCFM}
  1584.     INLINE $AA24;
  1585.     {$ENDC}
  1586. FUNCTION GetCTable(ctID: INTEGER): CTabHandle;
  1587.     {$IFC NOT GENERATINGCFM}
  1588.     INLINE $AA18;
  1589.     {$ENDC}
  1590. FUNCTION GetCCursor(crsrID: INTEGER): CCrsrHandle;
  1591.     {$IFC NOT GENERATINGCFM}
  1592.     INLINE $AA1B;
  1593.     {$ENDC}
  1594. PROCEDURE SetCCursor(cCrsr: CCrsrHandle);
  1595.     {$IFC NOT GENERATINGCFM}
  1596.     INLINE $AA1C;
  1597.     {$ENDC}
  1598. PROCEDURE AllocCursor;
  1599.     {$IFC NOT GENERATINGCFM}
  1600.     INLINE $AA1D;
  1601.     {$ENDC}
  1602. PROCEDURE DisposeCCursor(cCrsr: CCrsrHandle);
  1603.     {$IFC NOT GENERATINGCFM}
  1604.     INLINE $AA26;
  1605.     {$ENDC}
  1606. {$IFC OLDROUTINELOCATIONS }
  1607. FUNCTION GetCIcon(iconID: INTEGER): CIconHandle;
  1608.     {$IFC NOT GENERATINGCFM}
  1609.     INLINE $AA1E;
  1610.     {$ENDC}
  1611. PROCEDURE PlotCIcon({CONST}VAR theRect: Rect; theIcon: CIconHandle);
  1612.     {$IFC NOT GENERATINGCFM}
  1613.     INLINE $AA1F;
  1614.     {$ENDC}
  1615. PROCEDURE DisposeCIcon(theIcon: CIconHandle);
  1616.     {$IFC NOT GENERATINGCFM}
  1617.     INLINE $AA25;
  1618.     {$ENDC}
  1619. {$ENDC}
  1620. PROCEDURE SetStdCProcs(VAR procs: CQDProcs);
  1621.     {$IFC NOT GENERATINGCFM}
  1622.     INLINE $AA4E;
  1623.     {$ENDC}
  1624. FUNCTION GetMaxDevice({CONST}VAR globalRect: Rect): GDHandle;
  1625.     {$IFC NOT GENERATINGCFM}
  1626.     INLINE $AA27;
  1627.     {$ENDC}
  1628. FUNCTION GetCTSeed: LONGINT;
  1629.     {$IFC NOT GENERATINGCFM}
  1630.     INLINE $AA28;
  1631.     {$ENDC}
  1632. FUNCTION GetDeviceList: GDHandle;
  1633.     {$IFC NOT GENERATINGCFM}
  1634.     INLINE $AA29;
  1635.     {$ENDC}
  1636. FUNCTION GetMainDevice: GDHandle;
  1637.     {$IFC NOT GENERATINGCFM}
  1638.     INLINE $AA2A;
  1639.     {$ENDC}
  1640. FUNCTION GetNextDevice(curDevice: GDHandle): GDHandle;
  1641.     {$IFC NOT GENERATINGCFM}
  1642.     INLINE $AA2B;
  1643.     {$ENDC}
  1644. FUNCTION TestDeviceAttribute(gdh: GDHandle; attribute: INTEGER): BOOLEAN;
  1645.     {$IFC NOT GENERATINGCFM}
  1646.     INLINE $AA2C;
  1647.     {$ENDC}
  1648. PROCEDURE SetDeviceAttribute(gdh: GDHandle; attribute: INTEGER; value: BOOLEAN);
  1649.     {$IFC NOT GENERATINGCFM}
  1650.     INLINE $AA2D;
  1651.     {$ENDC}
  1652. PROCEDURE InitGDevice(qdRefNum: INTEGER; mode: LONGINT; gdh: GDHandle);
  1653.     {$IFC NOT GENERATINGCFM}
  1654.     INLINE $AA2E;
  1655.     {$ENDC}
  1656. FUNCTION NewGDevice(refNum: INTEGER; mode: LONGINT): GDHandle;
  1657.     {$IFC NOT GENERATINGCFM}
  1658.     INLINE $AA2F;
  1659.     {$ENDC}
  1660. PROCEDURE DisposeGDevice(gdh: GDHandle);
  1661.     {$IFC NOT GENERATINGCFM}
  1662.     INLINE $AA30;
  1663.     {$ENDC}
  1664. PROCEDURE SetGDevice(gd: GDHandle);
  1665.     {$IFC NOT GENERATINGCFM}
  1666.     INLINE $AA31;
  1667.     {$ENDC}
  1668. FUNCTION GetGDevice: GDHandle;
  1669.     {$IFC NOT GENERATINGCFM}
  1670.     INLINE $AA32;
  1671.     {$ENDC}
  1672. FUNCTION Color2Index({CONST}VAR myColor: RGBColor): LONGINT;
  1673.     {$IFC NOT GENERATINGCFM}
  1674.     INLINE $AA33;
  1675.     {$ENDC}
  1676. PROCEDURE Index2Color(index: LONGINT; VAR aColor: RGBColor);
  1677.     {$IFC NOT GENERATINGCFM}
  1678.     INLINE $AA34;
  1679.     {$ENDC}
  1680. PROCEDURE InvertColor(VAR myColor: RGBColor);
  1681.     {$IFC NOT GENERATINGCFM}
  1682.     INLINE $AA35;
  1683.     {$ENDC}
  1684. FUNCTION RealColor({CONST}VAR color: RGBColor): BOOLEAN;
  1685.     {$IFC NOT GENERATINGCFM}
  1686.     INLINE $AA36;
  1687.     {$ENDC}
  1688. PROCEDURE GetSubTable(myColors: CTabHandle; iTabRes: INTEGER; targetTbl: CTabHandle);
  1689.     {$IFC NOT GENERATINGCFM}
  1690.     INLINE $AA37;
  1691.     {$ENDC}
  1692. PROCEDURE MakeITable(cTabH: CTabHandle; iTabH: ITabHandle; res: INTEGER);
  1693.     {$IFC NOT GENERATINGCFM}
  1694.     INLINE $AA39;
  1695.     {$ENDC}
  1696. PROCEDURE AddSearch(searchProc: ColorSearchUPP);
  1697.     {$IFC NOT GENERATINGCFM}
  1698.     INLINE $AA3A;
  1699.     {$ENDC}
  1700. PROCEDURE AddComp(compProc: ColorComplementUPP);
  1701.     {$IFC NOT GENERATINGCFM}
  1702.     INLINE $AA3B;
  1703.     {$ENDC}
  1704. PROCEDURE DelSearch(searchProc: ColorSearchUPP);
  1705.     {$IFC NOT GENERATINGCFM}
  1706.     INLINE $AA4C;
  1707.     {$ENDC}
  1708. PROCEDURE DelComp(compProc: ColorComplementUPP);
  1709.     {$IFC NOT GENERATINGCFM}
  1710.     INLINE $AA4D;
  1711.     {$ENDC}
  1712. PROCEDURE SetClientID(id: INTEGER);
  1713.     {$IFC NOT GENERATINGCFM}
  1714.     INLINE $AA3C;
  1715.     {$ENDC}
  1716. PROCEDURE ProtectEntry(index: INTEGER; protect: BOOLEAN);
  1717.     {$IFC NOT GENERATINGCFM}
  1718.     INLINE $AA3D;
  1719.     {$ENDC}
  1720. PROCEDURE ReserveEntry(index: INTEGER; reserve: BOOLEAN);
  1721.     {$IFC NOT GENERATINGCFM}
  1722.     INLINE $AA3E;
  1723.     {$ENDC}
  1724. PROCEDURE SetEntries(start: INTEGER; count: INTEGER; VAR aTable: CSpecArray);
  1725.     {$IFC NOT GENERATINGCFM}
  1726.     INLINE $AA3F;
  1727.     {$ENDC}
  1728. PROCEDURE SaveEntries(srcTable: CTabHandle; resultTable: CTabHandle; VAR selection: ReqListRec);
  1729.     {$IFC NOT GENERATINGCFM}
  1730.     INLINE $AA49;
  1731.     {$ENDC}
  1732. PROCEDURE RestoreEntries(srcTable: CTabHandle; dstTable: CTabHandle; VAR selection: ReqListRec);
  1733.     {$IFC NOT GENERATINGCFM}
  1734.     INLINE $AA4A;
  1735.     {$ENDC}
  1736. FUNCTION QDError: INTEGER;
  1737.     {$IFC NOT GENERATINGCFM}
  1738.     INLINE $AA40;
  1739.     {$ENDC}
  1740. PROCEDURE CopyDeepMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1741.     {$IFC NOT GENERATINGCFM}
  1742.     INLINE $AA51;
  1743.     {$ENDC}
  1744. PROCEDURE DeviceLoop(drawingRgn: RgnHandle; drawingProc: DeviceLoopDrawingUPP; userData: LONGINT; flags: DeviceLoopFlags);
  1745.     {$IFC NOT GENERATINGCFM}
  1746.     INLINE $ABCA;
  1747.     {$ENDC}
  1748. FUNCTION GetMaskTable: Ptr;
  1749.     {$IFC NOT GENERATINGCFM}
  1750.     INLINE $A836, $2E88;
  1751.     {$ENDC}
  1752. FUNCTION GetPattern(patternID: INTEGER): PatHandle;
  1753.     {$IFC NOT GENERATINGCFM}
  1754.     INLINE $A9B8;
  1755.     {$ENDC}
  1756. FUNCTION GetCursor(cursorID: INTEGER): CursHandle;
  1757.     {$IFC NOT GENERATINGCFM}
  1758.     INLINE $A9B9;
  1759.     {$ENDC}
  1760. FUNCTION GetPicture(pictureID: INTEGER): PicHandle;
  1761.     {$IFC NOT GENERATINGCFM}
  1762.     INLINE $A9BC;
  1763.     {$ENDC}
  1764. FUNCTION DeltaPoint(ptA: Point; ptB: Point): LONGINT;
  1765.     {$IFC NOT GENERATINGCFM}
  1766.     INLINE $A94F;
  1767.     {$ENDC}
  1768. PROCEDURE ShieldCursor({CONST}VAR shieldRect: Rect; offsetPt: Point);
  1769.     {$IFC NOT GENERATINGCFM}
  1770.     INLINE $A855;
  1771.     {$ENDC}
  1772. PROCEDURE ScreenRes(VAR scrnHRes: INTEGER; VAR scrnVRes: INTEGER);
  1773.     {$IFC NOT GENERATINGCFM}
  1774.     INLINE $225F, $32B8, $0102, $225F, $32B8, $0104;
  1775.     {$ENDC}
  1776. PROCEDURE GetIndPattern(VAR thePat: Pattern; patternListID: INTEGER; index: INTEGER);
  1777. {$IFC OLDROUTINENAMES }
  1778. PROCEDURE DisposPixMap(pm: PixMapHandle);
  1779.     {$IFC NOT GENERATINGCFM}
  1780.     INLINE $AA04;
  1781.     {$ENDC}
  1782. PROCEDURE DisposPixPat(pp: PixPatHandle);
  1783.     {$IFC NOT GENERATINGCFM}
  1784.     INLINE $AA08;
  1785.     {$ENDC}
  1786. PROCEDURE DisposCTable(cTable: CTabHandle);
  1787.     {$IFC NOT GENERATINGCFM}
  1788.     INLINE $AA24;
  1789.     {$ENDC}
  1790. PROCEDURE DisposCCursor(cCrsr: CCrsrHandle);
  1791.     {$IFC NOT GENERATINGCFM}
  1792.     INLINE $AA26;
  1793.     {$ENDC}
  1794. {$IFC OLDROUTINELOCATIONS }
  1795. PROCEDURE DisposCIcon(theIcon: CIconHandle);
  1796.     {$IFC NOT GENERATINGCFM}
  1797.     INLINE $AA25;
  1798.     {$ENDC}
  1799. {$ENDC}
  1800. PROCEDURE DisposGDevice(gdh: GDHandle);
  1801.     {$IFC NOT GENERATINGCFM}
  1802.     INLINE $AA30;
  1803.     {$ENDC}
  1804. {$ENDC}
  1805.  
  1806. {$ALIGN RESET}
  1807. {$POP}
  1808.  
  1809. {$SETC UsingIncludes := QuickdrawIncludes}
  1810.  
  1811. {$ENDC} {__QUICKDRAW__}
  1812.  
  1813. {$IFC NOT UsingIncludes}
  1814.  END.
  1815. {$ENDC}
  1816.